笔记——文档在线阅读的解决方案（未完待续）

　　目前现在很多大型的网站或是某些项目需要让用户上传的文档可以在线预览。这个目前我所了解到的有以下几种情况：

　　　　1、pdf 在线阅读

　　　　2、office 在线阅读

　　对于pdf目前有很多解决方案了，可以参考 http://www.open-open.com/news/view/1fc3e18  ，对于office在线阅读，目前。我的办法是，先转换为PDF，然后使用pdf在线阅读的方式进行浏览。目前好像很多站点都是这么做的。

　　然而，我在项目中，这类文档在线阅读方案是这样的。OFFICE --> PDF  ---> SWF --> PNG 然后用户通过预览图片的方式去查看文档。

     这样做的目的就是，可以让尽可能多的平台直接观看文档，因为任何一个平台都能很好的支持PNG图片预览，但这样做，又产生了新的问题。

　　1、office 转成PDF 需要用安装office2007 + SaveAsPDFandXPS加载项 亦或是使用office 2010 。后则直接集成了这个加载项。让一个服务器安装一套office 然后功能仅仅用到的是将office转换为pdf。这个代价是比较大的。office还是不便宜的。

　　2、pdf 转换为 swf ，好在目前有现成的工具。（不需要UI界面）

　　3、swf 转换为 png ，目前也有现场的工具。（不需要UI界面）

　　4、因为这一系列过程才能正常的转换一个文档。而这样的工具，最适合的形态是windows 服务。这样不管如何，只要用户上传了文档，我们就可以进行转换。然而，理想是美好的。当我尝试将这个过程变成服务的过程中，遇到了新的问题。windows xp之后，服务是不能直接调用Application(ExE) 的。而将office转换为pdf，其原理是打开文档，使用另存为按钮，将它保存为pdf。而service 不支持图形界面的操作。在此，笔者查尽了资料。最后在CodeProject上找到了答案。原文我就不列举了，因为懒所以没有做笔记的习惯。代码如下：

   public class ProcessStarter : IDisposable
    {
        #region Import Section

        private static uint STANDARD_RIGHTS_REQUIRED = 0x000F0000;
        private static uint STANDARD_RIGHTS_READ = 0x00020000;
        private static uint TOKEN_ASSIGN_PRIMARY = 0x0001;
        private static uint TOKEN_DUPLICATE = 0x0002;
        private static uint TOKEN_IMPERSONATE = 0x0004;
        private static uint TOKEN_QUERY = 0x0008;
        private static uint TOKEN_QUERY_SOURCE = 0x0010;
        private static uint TOKEN_ADJUST_PRIVILEGES = 0x0020;
        private static uint TOKEN_ADJUST_GROUPS = 0x0040;
        private static uint TOKEN_ADJUST_DEFAULT = 0x0080;
        private static uint TOKEN_ADJUST_SESSIONID = 0x0100;
        private static uint TOKEN_READ = (STANDARD_RIGHTS_READ | TOKEN_QUERY);
        private static uint TOKEN_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED | TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_IMPERSONATE | TOKEN_QUERY | TOKEN_QUERY_SOURCE | TOKEN_ADJUST_PRIVILEGES | TOKEN_ADJUST_GROUPS | TOKEN_ADJUST_DEFAULT | TOKEN_ADJUST_SESSIONID);

        private const uint NORMAL_PRIORITY_CLASS = 0x0020;

        private const uint CREATE_UNICODE_ENVIRONMENT = 0x00000400;


        private const uint MAX_PATH = 260;

        private const uint CREATE_NO_WINDOW = 0x08000000;

        private const uint INFINITE = 0xFFFFFFFF;

        [StructLayout(LayoutKind.Sequential)]
        public struct SECURITY_ATTRIBUTES
        {
            public int nLength;
            public IntPtr lpSecurityDescriptor;
            public int bInheritHandle;
        }

        public enum SECURITY_IMPERSONATION_LEVEL
        {
            SecurityAnonymous,
            SecurityIdentification,
            SecurityImpersonation,
            SecurityDelegation
        }

        public enum TOKEN_TYPE
        {
            TokenPrimary = 1,
            TokenImpersonation
        }

        public enum WTS_CONNECTSTATE_CLASS
        {
            WTSActive,
            WTSConnected,
            WTSConnectQuery,
            WTSShadow,
            WTSDisconnected,
            WTSIdle,
            WTSListen,
            WTSReset,
            WTSDown,
            WTSInit
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct STARTUPINFO
        {
            public Int32 cb;
            public string lpReserved;
            public string lpDesktop;
            public string lpTitle;
            public Int32 dwX;
            public Int32 dwY;
            public Int32 dwXSize;
            public Int32 dwYSize;
            public Int32 dwXCountChars;
            public Int32 dwYCountChars;
            public Int32 dwFillAttribute;
            public Int32 dwFlags;
            public Int16 wShowWindow;
            public Int16 cbReserved2;
            public IntPtr lpReserved2;
            public IntPtr hStdInput;
            public IntPtr hStdOutput;
            public IntPtr hStdError;
        }

        [StructLayout(LayoutKind.Sequential)]
        internal struct PROCESS_INFORMATION
        {
            public IntPtr hProcess;
            public IntPtr hThread;
            public int dwProcessId;
            public int dwThreadId;
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct WTS_SESSION_INFO
        {
            public Int32 SessionID;

            [MarshalAs(UnmanagedType.LPStr)]
            public String pWinStationName;

            public WTS_CONNECTSTATE_CLASS State;
        }

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern uint WTSGetActiveConsoleSessionId();

        [DllImport("wtsapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern bool WTSQueryUserToken(int sessionId, out IntPtr tokenHandle);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        public extern static bool DuplicateTokenEx(IntPtr existingToken, uint desiredAccess, IntPtr tokenAttributes, SECURITY_IMPERSONATION_LEVEL impersonationLevel, TOKEN_TYPE tokenType, out IntPtr newToken);

        [DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern bool CreateProcessAsUser(IntPtr token, string applicationName, string commandLine, ref SECURITY_ATTRIBUTES processAttributes, ref SECURITY_ATTRIBUTES threadAttributes, bool inheritHandles, uint creationFlags, IntPtr environment, string currentDirectory, ref STARTUPINFO startupInfo, out PROCESS_INFORMATION processInformation);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern bool CloseHandle(IntPtr handle);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern int GetLastError();

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern int WaitForSingleObject(IntPtr token, uint timeInterval);

        [DllImport("wtsapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern int WTSEnumerateSessions(System.IntPtr hServer, int Reserved, int Version, ref System.IntPtr ppSessionInfo, ref int pCount);

        [DllImport("userenv.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern bool CreateEnvironmentBlock(out IntPtr lpEnvironment, IntPtr hToken, bool bInherit);

        [DllImport("wtsapi32.dll", ExactSpelling = true, SetLastError = false)]
        public static extern void WTSFreeMemory(IntPtr memory);

        [DllImport("userenv.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool DestroyEnvironmentBlock(IntPtr lpEnvironment);

        #endregion

        public ProcessStarter()
        {

        }

        public ProcessStarter(string processName, string fullExeName)
        {
            processName_ = processName;
            processPath_ = fullExeName;
        }
        public ProcessStarter(string processName, string fullExeName, string arguments)
        {
            processName_ = processName;
            processPath_ = fullExeName;
            arguments_ = arguments;
        }

        public static IntPtr GetCurrentUserToken()
        {
            IntPtr currentToken = IntPtr.Zero;
            IntPtr primaryToken = IntPtr.Zero;
            IntPtr WTS_CURRENT_SERVER_HANDLE = IntPtr.Zero;

            int dwSessionId = 0;
            IntPtr hUserToken = IntPtr.Zero;
            IntPtr hTokenDup = IntPtr.Zero;

            IntPtr pSessionInfo = IntPtr.Zero;
            int dwCount = 0;

            WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, ref pSessionInfo, ref dwCount);

            Int32 dataSize = Marshal.SizeOf(typeof(WTS_SESSION_INFO));

            Int32 current = (int)pSessionInfo;
            for (int i = 0; i < dwCount; i++)
            {
                WTS_SESSION_INFO si = (WTS_SESSION_INFO)Marshal.PtrToStructure((System.IntPtr)current, typeof(WTS_SESSION_INFO));
                if (WTS_CONNECTSTATE_CLASS.WTSActive == si.State)
                {
                    dwSessionId = si.SessionID;
                    break;
                }

                current += dataSize;
            }

            WTSFreeMemory(pSessionInfo);

            bool bRet = WTSQueryUserToken(dwSessionId, out currentToken);
            if (bRet == false)
            {
                return IntPtr.Zero;
            }

            bRet = DuplicateTokenEx(currentToken, TOKEN_ASSIGN_PRIMARY | TOKEN_ALL_ACCESS, IntPtr.Zero, SECURITY_IMPERSONATION_LEVEL.SecurityImpersonation, TOKEN_TYPE.TokenPrimary, out primaryToken);
            if (bRet == false)
            {
                return IntPtr.Zero;
            }

            return primaryToken;
        }

        public void Run()
        {

            IntPtr primaryToken = GetCurrentUserToken();
            if (primaryToken == IntPtr.Zero)
            {
                return;
            }
            STARTUPINFO StartupInfo = new STARTUPINFO();
            processInfo_ = new PROCESS_INFORMATION();
            StartupInfo.cb = Marshal.SizeOf(StartupInfo);

            SECURITY_ATTRIBUTES Security1 = new SECURITY_ATTRIBUTES();
            SECURITY_ATTRIBUTES Security2 = new SECURITY_ATTRIBUTES();

            string command = """ + processPath_ + """;
            if ((arguments_ != null) && (arguments_.Length != 0))
            {
                command += " " + arguments_;
            }

            IntPtr lpEnvironment = IntPtr.Zero;
            bool resultEnv = CreateEnvironmentBlock(out lpEnvironment, primaryToken, false);
            if (resultEnv != true)
            {
                int nError = GetLastError();
            }

            CreateProcessAsUser(primaryToken, null, command, ref Security1, ref Security2, false, CREATE_NO_WINDOW | NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT, lpEnvironment, null, ref StartupInfo, out processInfo_);

            DestroyEnvironmentBlock(lpEnvironment);
            CloseHandle(primaryToken);
        }

        public void Stop()
        {
            Process[] processes = Process.GetProcesses();
            foreach (Process current in processes)
            {
                if (current.ProcessName == processName_)
                {
                    current.Kill();
                }
            }
        }

        public int WaitForExit()
        {
            WaitForSingleObject(processInfo_.hProcess, INFINITE);
            int errorcode = GetLastError();
            return errorcode;
        }

        #region IDisposable Members

        public void Dispose()
        {
        }

        #endregion

        private string processPath_ = string.Empty;
        private string processName_ = string.Empty;
        private string arguments_ = string.Empty;
        private PROCESS_INFORMATION processInfo_;

        public string ProcessPath
        {
            get
            {
                return processPath_;
            }
            set
            {
                processPath_ = value;
            }
        }

        public string ProcessName
        {
            get
            {
                return processName_;
            }
            set
            {
                processName_ = value;
            }
        }

        public string Arguments
        {
            get
            {
                return arguments_;
            }
            set
            {
                arguments_ = value;
            }
        }
    }

其调用方式，如下：

 ProcessStarter  ps = new ProcessStarter(RunProcessName, "Worker.exe");
                     ps.Run();

第一个参数，是外壳程序，也就是说，当系统登录的时候一定会存在的进程。也就是Login之后，当前用户一定会存在的进程。

第二个参数，是我们需要运行的Application。

这样就可以在windows service中Call到Application了。

到了这里问题好像解决了。但是，我发现服务器必须需要一个用户登录进去，Office 才能转换为PDF。分析了很久的原因。后来突然有一天发现。以为没有Login之前。是没有UI界面的。在没有UI界面之前是不可能打开Office的。所以此路不通！！！

于是乎，继续寻找解决办法。就在昨天，我发现了新的解决办法。但还没有去尝试。如果有人有现场的解决办法，希望能拿出来分享下。

1、Aspose.words.dll 听说这玩意儿可以在不安装OFFICE的情况下将word转换为pdf。目前我没有验证。但，仅仅只能将word转换为pdf还是不够的，我们还有 ppt excel。再者版本问题也是个问题。是否支持 Office 2003 和 Office 2007以上版本。

2、OpenOffice 这个家伙是阿帕奇搞的。听说可以不依靠office的情况下处理这些。但是太大了。我也没来得及去详细的查阅资料。

最后，期待第二篇日志可以解决以上问题。让office文档能在脱离安装office的情况下完美转换。