整理了下Vuforia 6-2-10 版本對應識別功能的函數(shù)

• TrackableSettings類主要功能

  • 開啟擴展追蹤

  • 獲取當前激活識別庫名稱列表

  • 激活指定的識別數(shù)據(jù)集

  • 關(guān)閉指定識別數(shù)據(jù)集

  • 動態(tài)載入識別數(shù)據(jù)集

  • 卸載所有識別數(shù)據(jù)集（識別庫）

  • 設(shè)置同時識別Image的個數(shù)

  • 設(shè)置同時識別3D物體的個數(shù)

代碼塊如下

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using Vuforia;

/// <summary>
/// 追蹤功能設(shè)置類
/// </summary>
public class TrackableSettings : MonoBehaviour
{
    public const string Name = "TrackableSettings";
    static TrackableSettings() { }
    protected TrackableSettings() { }
    protected static volatile TrackableSettings instance = null;
    protected readonly object msyncRoot = new object();
    protected static readonly object mstaticSyncRoot = new object();
    public static TrackableSettings Instance
    {
        get
        {
            if (instance == null)
            {
                lock (mstaticSyncRoot)
                {
                    if (instance == null) instance = new GameObject(Name).AddComponent<TrackableSettings>();
                }
            }
            return instance;
        }
    }

    /// <summary>
    /// 識別數(shù)據(jù)集所在的文件路徑
    /// </summary>
    private string dataSetDirectoryPath = null;

/// <summary>
/// 已經(jīng)激活的識別數(shù)據(jù)集
/// </summary>
    protected Dictionary<string, string> mCurrentActiveDataSets = new Dictionary<string, string>();
    /// <summary>
    /// 所有數(shù)據(jù)集對應的路徑
    /// </summary>
    protected Dictionary<string, string> mCurrentAllDataSets = new Dictionary<string, string>();
    /// <summary>
    /// 是否使用本地內(nèi)置識別庫
    /// </summary>
    public bool bLocal = false;
    /// <summary>
    /// 擴展追蹤是否開啟
    /// </summary>
    protected bool mExtTrackingEnabled = false;


    private void Awake()
    {
        //if (m_instance == null) m_instance = this;

        //if (gameObject.name == "GameObject") gameObject.name = Name;
    }

    private void Start()
    {
        Initialize();
    }

    private void Initialize()
    {
        dataSetDirectoryPath = Application.persistentDataPath + "/" + "DataDirectory"+"/";

        if (!Directory.Exists(dataSetDirectoryPath))
        {
            Directory.CreateDirectory(dataSetDirectoryPath);
        }
    }
    /// <summary>
    /// 獲得擴展追蹤開啟狀態(tài)
    /// </summary>
    /// <returns></returns>
    public bool IsExtendedTrackingEnabled()
    {
        return mExtTrackingEnabled;
    }

    /// <summary>
    /// 開啟、關(guān)閉擴展追蹤模式
    /// </summary>
    /// <param name="extTrackingEnabled">是否開啟</param>
    public virtual void SwitchExtendedTracking(bool extTrackingEnabled)
    {
        //返回可以訪問當前所有跟蹤的狀態(tài)管理器實例。
        StateManager stateManager = TrackerManager.Instance.GetStateManager();

        // 我們遍歷所有trackablebehaviours啟動或停止擴展跟蹤他們所代表的目標。
        bool success = true;
        foreach (var tb in stateManager.GetTrackableBehaviours())
        {
            if (tb is ImageTargetBehaviour)
            {
                ImageTargetBehaviour itb = tb as ImageTargetBehaviour;
                if (extTrackingEnabled)
                {
                    if (!itb.ImageTarget.StartExtendedTracking())
                    {
                        success = false;
                        Debug.LogError("擴展跟蹤開始失敗，對應目標： " + itb.TrackableName);
                    }
                }
                else
                {
                    itb.ImageTarget.StopExtendedTracking();
                }
            }
            else if (tb is MultiTargetBehaviour)
            {
                MultiTargetBehaviour mtb = tb as MultiTargetBehaviour;
                if (extTrackingEnabled)
                {
                    if (!mtb.MultiTarget.StartExtendedTracking())
                    {
                        success = false;
                        Debug.LogError("Failed to start Extended Tracking on Target " + mtb.TrackableName);
                    }
                }
                else
                {
                    mtb.MultiTarget.StopExtendedTracking();
                }
            }
            else if (tb is CylinderTargetBehaviour)
            {
                CylinderTargetBehaviour ctb = tb as CylinderTargetBehaviour;
                if (extTrackingEnabled)
                {
                    if (!ctb.CylinderTarget.StartExtendedTracking())
                    {
                        success = false;
                        Debug.LogError("Failed to start Extended Tracking on Target " + ctb.TrackableName);
                    }
                }
                else
                {
                    ctb.CylinderTarget.StopExtendedTracking();
                }
            }
            else if (tb is ObjectTargetBehaviour)
            {
                ObjectTargetBehaviour otb = tb as ObjectTargetBehaviour;
                if (extTrackingEnabled)
                {
                    if (!otb.ObjectTarget.StartExtendedTracking())
                    {
                        success = false;
                        Debug.LogError("Failed to start Extended Tracking on Target " + otb.TrackableName);
                    }
                }
                else
                {
                    otb.ObjectTarget.StopExtendedTracking();
                }
            }
            else if (tb is VuMarkBehaviour)
            {
                VuMarkBehaviour vmb = tb as VuMarkBehaviour;
                if (extTrackingEnabled)
                {
                    if (!vmb.VuMarkTemplate.StartExtendedTracking())
                    {
                        success = false;
                        Debug.LogError("Failed to start Extended Tracking on Target " + vmb.TrackableName);
                    }
                }
                else
                {
                    vmb.VuMarkTemplate.StopExtendedTracking();
                }
            }
        }
        mExtTrackingEnabled = success && extTrackingEnabled;
    }
    /// <summary>
    /// 獲取當前激活識別庫名稱列表
    /// </summary>
    /// <returns></returns>
    public List<string> GetActiveDatasetNameList()
    {
        ObjectTracker tracker = TrackerManager.Instance.GetTracker<ObjectTracker>();
        List<DataSet> activeDataSets = tracker.GetActiveDataSets().ToList();
        List<string> tempList = new List<string>();
        for (int i = 0 ; i < activeDataSets.Count ; i++)
        {
            string datasetPath = activeDataSets.ElementAt(i).Path;
            Debug.Log("datasetPath:" + datasetPath);
            string datasetName = datasetPath.Substring(datasetPath.LastIndexOf("/") + 1);
            Debug.Log("datasetName:" + datasetName);
            tempList.Add(datasetName.TrimEnd(".xml".ToCharArray()));
        }
        return tempList;
    }
    /// <summary>
    /// 激活指定的識別數(shù)據(jù)集
    /// </summary>
    /// <param name="datasetName">數(shù)據(jù)集名稱或絕對路徑</param>
    public virtual void ActivateDataSet(string datasetName)
    {
        if (mCurrentActiveDataSets.ContainsKey(datasetName))
        {
            Debug.Log(string.Format("要激活的識別庫:{0}已經(jīng)加載", datasetName));
            return;
        } 

        // objecttracker跟蹤包含在數(shù)據(jù)集，提供了用于創(chuàng)建和方法的激活數(shù)據(jù)。
        ObjectTracker objectTracker = TrackerManager.Instance.GetTracker<ObjectTracker>();
        IEnumerable<DataSet> datasets = objectTracker.GetDataSets();

        IEnumerable<DataSet> activeDataSets = objectTracker.GetActiveDataSets();
        List<DataSet> activeDataSetsToBeRemoved = activeDataSets.ToList();

        // 1. 循環(huán)遍歷所有的活動數(shù)據(jù)集并禁用它們
        foreach (DataSet ads in activeDataSetsToBeRemoved)
        {
            objectTracker.DeactivateDataSet(ads);
        }

        // 在ObjectTracker運行時，不應該對數(shù)據(jù)集進行交換
        // 2. 所以首先要關(guān)閉tracker
        objectTracker.Stop();

        // 3. 然后，查找新數(shù)據(jù)集，如果存在，激活它
        foreach (DataSet ds in datasets)
        {
            if (ds.Path.Contains(datasetName))
            {
                objectTracker.ActivateDataSet(ds);
                mCurrentActiveDataSets.Add(datasetName, ds.Path);
            }
        }

        // 4. 最后重啟traker.
        objectTracker.Start();
    }

    /// <summary>
    /// 關(guān)閉指定識別數(shù)據(jù)集
    /// </summary>
    /// <param name="datasetName">數(shù)據(jù)集名稱或絕對路徑</param>
    public virtual void DeactivateDateset(string datasetName)
    {
        if (!mCurrentActiveDataSets.ContainsKey(datasetName))
        {
            Debug.Log(string.Format("要關(guān)閉的識別庫:{0}不存在", datasetName));
            return;
        }

        ObjectTracker objectTracker = TrackerManager.Instance.GetTracker<ObjectTracker>();
        IEnumerable<DataSet> datasets = objectTracker.GetDataSets();

        IEnumerable<DataSet> activeDataSets = objectTracker.GetActiveDataSets();

        List<DataSet> activeDataSetsToBeRemoved = activeDataSets.ToList();

        List<DataSet> dataSetsToBeActive = new List<DataSet>();

        foreach (DataSet ads in activeDataSetsToBeRemoved)
        {
            if (!ads.Path.Contains(datasetName))
            {
                dataSetsToBeActive.Add(ads);
            }
            objectTracker.DeactivateDataSet(ads);
        }

        objectTracker.Stop();

        foreach (DataSet ds in dataSetsToBeActive)
        {
            objectTracker.ActivateDataSet(ds);
        }
        mCurrentActiveDataSets.Remove(datasetName);

        objectTracker.Start();
    }
    /// <summary>
    /// 載入識別數(shù)據(jù)集
    /// </summary>
    /// <param name="DataSetName">數(shù)據(jù)集名稱</param>
    /// <param name="Local">是否是本地識別數(shù)據(jù)集</param>
    public virtual void LoadDataSet(string DataSetName, bool Local = true)
    {
        ObjectTracker objectTracker = TrackerManager.Instance.GetTracker<ObjectTracker>();
        objectTracker.Stop();
        bool bLoadDataSet = false;
        DataSet mDataSet = null;
        if (VuforiaRuntimeUtilities.IsVuforiaEnabled())
        {
            objectTracker = TrackerManager.Instance.GetTracker<ObjectTracker>();
            mDataSet = objectTracker.CreateDataSet();
            if (!Local)
            {
                bLoadDataSet = mDataSet.Load(dataSetDirectoryPath+DataSetName+".xml", VuforiaUnity.StorageType.STORAGE_ABSOLUTE);//絕對路徑 一般用來加載網(wǎng)絡(luò)下載的識別庫（dat和xml文件）  
            }
            else
            {
                bLoadDataSet = mDataSet.Load(DataSetName);//本地預制的識別庫  
            }
        }

        if (bLoadDataSet)
        {
            mCurrentAllDataSets.Add(DataSetName, mDataSet.Path);

            UpdateImageTarget();
            Debug.Log("加載識別數(shù)據(jù)庫成功并激活");

            if (objectTracker.ActivateDataSet(mDataSet))
            {
                mCurrentActiveDataSets.Add(DataSetName, mDataSet.Path);
            }
            else
            {
                Debug.Log(DataSetName + "激活失敗");
            }

        }
        else
        {
            Debug.Log("加載識別數(shù)據(jù)庫失敗");
        }

        CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_TRIGGERAUTO);

        CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO);

        objectTracker.Start();//開啟識別器 （可以理解為攝像頭）  
    }
    /// <summary>
    /// 更新ImageTarget上的信息
    /// </summary>
   public virtual void UpdateImageTarget()
    {
        ImageTargetBehaviour[] m_ImageTargetBehaviours = GameObject.FindObjectsOfType<ImageTargetBehaviour>();
        for (int i = 0 ; i < m_ImageTargetBehaviours.Length ; i++)
        {
            ImageTargetBehaviour imageTargetBehaviour = m_ImageTargetBehaviours[i];
            imageTargetBehaviour.name = m_ImageTargetBehaviours[i].ImageTarget.Name + "Target";
            imageTargetBehaviour.gameObject.AddComponent<DefaultTrackableEventHandler>();
            imageTargetBehaviour.gameObject.AddComponent<TurnOffBehaviour>();
        }
    }
    /// <summary>
    /// 卸載所有識別數(shù)據(jù)集（識別庫）
    /// </summary>
    public virtual void UnLoadAllDataSet()
    {
        ObjectTracker objectTracker = TrackerManager.Instance.GetTracker<ObjectTracker>();
        bool isVuforiaEnabled = VuforiaRuntimeUtilities.IsVuforiaEnabled();

        if (isVuforiaEnabled)
        {
            //1. 關(guān)閉跟蹤器
            objectTracker.Stop();
            //獲取對應數(shù)據(jù)集合集（和激活數(shù)據(jù)集寫法略有不同）
            IEnumerable<DataSet> dataSets = objectTracker.GetActiveDataSets();
            IEnumerator<DataSet> dEnumerator = dataSets.GetEnumerator();
            List<DataSet> listDataSet = new List<DataSet>();

            while (dEnumerator.MoveNext())
            {
                listDataSet.Add(dEnumerator.Current);
            }
            //關(guān)閉每一個數(shù)據(jù)集
            for (int i = 0 ; i < listDataSet.Count ; i++)
            {
                Debug.Log("關(guān)閉對應數(shù)據(jù)集：" + listDataSet[i].Path);
                objectTracker.DeactivateDataSet(listDataSet[i]);
            }

            for (int i = 0 ; i < listDataSet.Count ; i++)
            {
                Debug.Log("關(guān)閉對應數(shù)據(jù)集：" + listDataSet[i].Path);
                objectTracker.DestroyDataSet(listDataSet[i], false);
            }

            //管理所有可跟蹤行為的狀態(tài)
            StateManager stateManager = TrackerManager.Instance.GetStateManager();
            //ImageTargetBehaviour[] ImageTargetBehaviours = GameObject.FindObjectsOfType<ImageTargetBehaviour>();
            IEnumerable<TrackableBehaviour> IETrackableBehaviours = stateManager.GetTrackableBehaviours();
            //銷毀對應創(chuàng)建的ImageTarget跟蹤具體行為（就是在imagetarget上設(shè)置的參數(shù)）和銷毀對應的GameObject
            foreach (var tb in IETrackableBehaviours)
            {
                stateManager.DestroyTrackableBehavioursForTrackable(tb.Trackable, true);
            }
            objectTracker.DestroyAllDataSets(true);
            Debug.Log("銷毀識別數(shù)據(jù)成功");

            mCurrentActiveDataSets.Clear();
            mCurrentAllDataSets.Clear();
        }
        else
        {
            Debug.Log("銷毀數(shù)據(jù)失敗");
        }
    }

    /// <summary>
    /// 設(shè)置同時識別Image的個數(shù)
    /// </summary>
    /// <param name="TrackedCount"></param>
    public virtual void SetTrackedImageCount(int TrackedCount)
    {
        VuforiaUnity.SetHint(VuforiaUnity.VuforiaHint.HINT_MAX_SIMULTANEOUS_IMAGE_TARGETS, TrackedCount);
    }
    /// <summary>
    /// 設(shè)置同時識別3D物體的個數(shù)
    /// </summary>
    /// <param name="TrackedCount"></param>
    public virtual void SetTrackedObjectCount(int TrackedCount)
    {
        VuforiaUnity.SetHint(VuforiaUnity.VuforiaHint.HINT_MAX_SIMULTANEOUS_OBJECT_TARGETS, TrackedCount);
    }
}

• FrameRateSettings類主要功能

  • 設(shè)置對應幀率

代碼塊如下：

using UnityEngine;
using Vuforia;


/// <summary>
///幀率設(shè)置類
/// </summary>
public class FrameRateSettings : MonoBehaviour
{
    public const string Name = "FrameRateSettings";
    static FrameRateSettings() { }
    protected FrameRateSettings() { }
    protected static volatile FrameRateSettings instance = null;
    protected readonly object msyncRoot = new object();
    protected static readonly object mstaticSyncRoot = new object();

    public static FrameRateSettings Instance
    {
        get
        {
            if (instance == null)
            {
                lock (mstaticSyncRoot)
                {
                    if (instance == null) instance = new GameObject(Name).AddComponent<FrameRateSettings>();
                }
            }
            return instance;
        }
    }

    void Awake()
    {
        //if (m_instance == null) m_instance = this;

        //if (gameObject.name == "GameObject") gameObject.name = Name;
    }


    void Start()
    {
        VuforiaARController.Instance.RegisterVuforiaStartedCallback(OnVuforiaStarted);
    }


    /// <summary>
    /// 高通全面啟動的幀率設(shè)置回調(diào)
    /// </summary>
    private void OnVuforiaStarted()
    {
        //查詢在unity中推薦的幀率（默認 AR或VR  省電 高幀數(shù) 四種模式）

        int targetFps = VuforiaRenderer.Instance.GetRecommendedFps(VuforiaRenderer.FpsHint.NONE);

        /*默認情況下，我們使用application.targetframerate設(shè)置推薦的幀速率。
         谷歌紙板不使用垂直同步，和OVR明確禁用它。如果開發(fā)商
         使用VSYNC的質(zhì)量設(shè)置，他們也應該把他們的qualitysettings.vsynccount
           根據(jù)上面返回的值。
         例如：如果物體的FPS > 50 > vsynccount = 1；其他vsynccount = 2；
        */
        if (Application.targetFrameRate != targetFps)
        {
            Debug.Log("Setting frame rate to " + targetFps + "fps");
            Application.targetFrameRate = targetFps;
        }
    }

}

• CameraSettings類主要功能

  • 開啟閃光燈

  • 開啟自動對焦

  • 前后攝像機切換

代碼塊如下：

using UnityEngine;
using System.Collections;
using Vuforia;
/// <summary>
/// 攝像機功能設(shè)置類
/// </summary>
public class CameraSettings : MonoBehaviour
{
    public const string Name = "CameraSettings";
    static CameraSettings() { }
    protected CameraSettings() { }
    protected static volatile CameraSettings instance = null;
    protected readonly object msyncRoot = new object();
    protected static readonly object mstaticSyncRoot = new object();


    public static CameraSettings Instance
    {
        get
        {
            if (instance == null)
            {
                lock (mstaticSyncRoot)
                {
                    if (instance == null) instance = new GameObject(Name).AddComponent<CameraSettings>();
                }
            }
            return instance;
        }

    }
    /// <summary>
    /// Vuforia是否完全啟動
    /// </summary>
    private bool mVuforiaStarted = false;
    /// <summary>
    /// 自動對焦是否開啟
    /// </summary>
    private bool mAutofocusEnabled = true;
    /// <summary>
    /// 閃光燈是否開啟
    /// </summary>
    private bool mFlashTorchEnabled = false;
    /// <summary>
    /// 攝像頭朝向
    /// </summary>
    private CameraDevice.CameraDirection mActiveDirection = CameraDevice.CameraDirection.CAMERA_DEFAULT;

    void Awake()
    {
        //if (m_instance == null) m_instance = this;

        //if (gameObject.name == "GameObject") gameObject.name = Name;
    }

    void Start()
    {
        VuforiaARController vuforia = VuforiaARController.Instance;
        //vuforia已經(jīng)全面啟動回調(diào)，包括相機和跟蹤器。可以注冊多個回調(diào)函數(shù)
        vuforia.RegisterVuforiaStartedCallback(OnVuforiaStarted);
        //停止和恢復的回調(diào)，這個是回復后重新讓攝像機對焦（對應狀態(tài)自動傳入對應的bool值）
        vuforia.RegisterOnPauseCallback(OnPaused);
    }
    /// <summary>
    /// Vuforia完全啟動回調(diào)
    /// </summary>
    private void OnVuforiaStarted()
    {
        mVuforiaStarted = true;
        //開啟自動對焦
        SwitchAutofocus(true);
    }
    /// <summary>
    /// Vuforia停止和恢復的回調(diào)
    /// </summary>
    /// <param name="paused"></param>
    private void OnPaused(bool paused)
    {
        bool appResumed = !paused;
        if (appResumed && mVuforiaStarted)
        {
            // 恢復原來的對焦方式
            if (mAutofocusEnabled)
                CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO);
            else
                CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_NORMAL);
        }
        else
        {
            //閃光燈狀態(tài)更改 因為閃光燈會自動被操作系統(tǒng)關(guān)閉
            mFlashTorchEnabled = false;
        }
    }

    /// <summary>
    /// 閃光燈打開或或關(guān)閉狀態(tài)
    /// </summary>
    /// <returns></returns>
    public bool IsFlashTorchEnabled()
    {
        return mFlashTorchEnabled;
    }
    /// <summary>
    /// 閃光燈開關(guān)
    /// </summary>
    /// <param name="ON">是否開啟閃光燈</param>
    public virtual void SwitchFlashTorch(bool ON)
    {
        if (CameraDevice.Instance.SetFlashTorchMode(ON))
        {
            Debug.Log("成功開啟閃光燈 " + ON);
            mFlashTorchEnabled = ON;
        }
        else
        {
            Debug.Log("開啟閃光燈失敗 " + ON);
            mFlashTorchEnabled = false;
        }
    }

    public virtual bool IsAutofocusEnabled()
    {
        return mAutofocusEnabled;
    }
    /// <summary>
    /// 是否開啟自動對焦
    /// </summary>
    /// <param name="ON">是否開啟自動對焦</param>
    public virtual void SwitchAutofocus(bool ON)
    {
        if (ON)
        {
            if (CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO))
            {
                Debug.Log("成功開啟連續(xù)對焦");
                mAutofocusEnabled = true;
            }
            else
            {
                // Fallback to normal focus mode
                Debug.Log("未能啟用連續(xù)自動對焦，切換到正常對焦模式");
                mAutofocusEnabled = false;
                CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_NORMAL);
            }
        }
        else
        {
            Debug.Log("禁用連續(xù)自動對焦（啟用正常對焦模式）.");
            mAutofocusEnabled = false;
            CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_NORMAL);
        }
    }
    /// <summary>
    /// 強制觸發(fā)一次對焦
    /// </summary>
    public virtual void TriggerAutofocusEvent()
    {

        CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_TRIGGERAUTO);

        // 恢復到原來的對焦模式
        StartCoroutine(RestoreOriginalFocusMode());
    }

    private IEnumerator RestoreOriginalFocusMode()
    {
        yield return new WaitForSeconds(1.5f);

        if (mAutofocusEnabled)
        {
            CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_CONTINUOUSAUTO);
        }
        else
        {
            CameraDevice.Instance.SetFocusMode(CameraDevice.FocusMode.FOCUS_MODE_NORMAL);
        }
    }

    /// <summary>
    /// 前后攝像機切換
    /// </summary>
    /// <param name="camDir">攝像機方向</param>
    public virtual void SelectCamera(CameraDevice.CameraDirection camDir)
    {
        if (RestartCamera(camDir))
        {
            mActiveDirection = camDir;

            // Upon camera restart, flash is turned off
            mFlashTorchEnabled = false;
        }
    }
    /// <summary>
    /// 轉(zhuǎn)換攝像機需要把原來的攝像機狀態(tài)關(guān)掉卸載然后重新初始化
    /// </summary>
    /// <param name="direction">攝像機方向</param>
    /// <returns></returns>
    public virtual bool RestartCamera(CameraDevice.CameraDirection direction)
    {
        ObjectTracker tracker = TrackerManager.Instance.GetTracker<ObjectTracker>();
        if (tracker != null)
        {
            tracker.Stop();
        }

        CameraDevice.Instance.Stop();
        CameraDevice.Instance.Deinit();

        if (!CameraDevice.Instance.Init(direction))
        {
            Debug.Log("初始化失敗，指定的方向為: " + direction.ToString());
            return false;
        }
        if (!CameraDevice.Instance.Start())
        {
            Debug.Log("攝像機啟動失敗，指定的方向為: " + direction.ToString());
            return false;
        }

        if (tracker != null)
        {
            if (!tracker.Start())
            {
                Debug.Log("Tracker重新啟動失敗");
                return false;
            }
        }

        return true;
    }
    /// <summary>
    /// 在IOS上翻轉(zhuǎn)攝像頭會出現(xiàn)攝像頭上下顛倒的情況，在CameraDevice.Instance.Start()后調(diào)用次函數(shù)，反之忽略即可
    /// </summary>
    /// <returns></returns>
    IEnumerator Refresh()
    {
        yield return new WaitForEndOfFrame();
        Camera.main.transform.localEulerAngles = new Vector3(0, 0, 180.0f);
    }
    /// <summary>
    /// 是否為前置攝像頭
    /// </summary>
    /// <returns></returns>
    public virtual bool IsFrontCameraActive()
    {
        return (mActiveDirection == CameraDevice.CameraDirection.CAMERA_FRONT);
    }

}

• InitErrorHandler類主要功能

  • Vuforia初始化時對應錯誤的回調(diào)(CustomLog自己封裝的)

代碼塊如下：

using UnityEngine;
using System.Collections;
using Vuforia;
using Custom.Log;

public class InitErrorHandler : MonoBehaviour
{
    private string key;
    void Awake()
    {
        VuforiaRuntime.Instance.RegisterVuforiaInitErrorCallback(OnInitError);
        if (Debuger.EnableLog)
        {
            Debug.Log("+");
        }
        else
        {
            Debug.Log("-");
        }
    }
    private void OnInitError(VuforiaUnity.InitError error)
    {
        if (error != VuforiaUnity.InitError.INIT_SUCCESS)
        {
            ShowErrorMessage(error);
        }
    }
    private void CustomLog(string str)
    {
        this.Log(str);
    }

    private void ShowErrorMessage(VuforiaUnity.InitError errorCode)
    {
        switch (errorCode)
        {
            //外部設(shè)備檢測失敗錯誤（攝像頭）
            case VuforiaUnity.InitError.INIT_EXTERNAL_DEVICE_NOT_DETECTED:
                {
                    string temp = "Vuforia初始化失敗 " + "沒有設(shè)備所需的外部硬件對接";
                    CustomLog(temp);
                    break;
                }
            // 沒有輸入密鑰的錯誤
            case VuforiaUnity.InitError.INIT_LICENSE_ERROR_MISSING_KEY:
                {
                    string temp = "Vuforia 密鑰沒有找到";
                    CustomLog(temp);
                }
                break;
            // 輸入的密鑰無效的錯誤
            case VuforiaUnity.InitError.INIT_LICENSE_ERROR_INVALID_KEY:
                {
                    key = VuforiaConfiguration.Instance.Vuforia.LicenseKey;
                    if (key.Length > 10)
                    {
                        string temp = "Vuforia 密鑰無效：請申請有效的密鑰";
                        CustomLog(temp);
                    }
                    else
                    {
                        string temp = "Vuforia 密鑰無效：密鑰不完整";
                        CustomLog(temp);
                    }
                    break;
                }
            case VuforiaUnity.InitError.INIT_LICENSE_ERROR_NO_NETWORK_TRANSIENT:
                {
                    string temp =
   "無法接觸服務器。請稍后再試";
                    CustomLog(temp);
                    break;
                }
            case VuforiaUnity.InitError.INIT_LICENSE_ERROR_NO_NETWORK_PERMANENT:
                {
                    string temp =
   "沒有可用的網(wǎng)絡(luò)。請確保你與互聯(lián)網(wǎng)連接。";
                    CustomLog(temp);
                    break;
                }
            case VuforiaUnity.InitError.INIT_LICENSE_ERROR_CANCELED_KEY:
                {
                    key = VuforiaConfiguration.Instance.Vuforia.LicenseKey;
                    string temp = "這款應用程序的許可密鑰已被取消，可能不再使用";
                    CustomLog(temp);
                    break;
                }
            case VuforiaUnity.InitError.INIT_LICENSE_ERROR_PRODUCT_TYPE_MISMATCH:
                {
                    key = VuforiaConfiguration.Instance.Vuforia.LicenseKey;
                    string temp = "輸入的密鑰與對應的產(chǎn)品不相符";
                    CustomLog(temp);
                }
                break;
//#if (UNITY_IPHONE || UNITY_IOS)
                case VuforiaUnity.InitError.INIT_NO_CAMERA_ACCESS:
                {
                    string temp =
                       "當在iOS設(shè)備上運行時，用戶必須明確允許該應用訪問攝像頭。要恢復設(shè)備上的攝像頭訪問權(quán)限，請訪問" +
                       "Settings > Privacy > Camera > [萌伴小學堂] 然后開啟權(quán)限";
                    CustomLog(temp);
                    break;
                }
//#endif
            case VuforiaUnity.InitError.INIT_DEVICE_NOT_SUPPORTED:
                {
                    string temp =
   "Vuforia初始化失敗：此設(shè)備不支持";
                    CustomLog(temp);
                    break;
                }

            case VuforiaUnity.InitError.INIT_ERROR:
                {
                    string temp = "Vuforia初始化失敗：未知";
                    CustomLog(temp);
                    break;
                }
        }

        Debug.Log(errorCode);



    } //PRIVATE_METHODS

}