ctr_Repair/branches/SelfCupExecChecker/main.cpp

/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     main.cpp

  Copyright (C)2009 Nintendo Co., Ltd.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Rev$
 *---------------------------------------------------------------------------*/

#include <nn.h>
#include <nn/os.h>
#include <nn/dbg.h>
#include <nn/CTR.h>
#include <nn/ns.h>
#include <nn/ns/CTR/ns_ApiShell.h>
#include <nn/ns/CTR/ns_Shell.h>
#include <nn/fs/fs_FileSystemBase.h>
#include <nn/fs/CTR/MPCore/fs_FileSystemBasePrivate.h>
#include <nn/applet/CTR/applet_APIForSystem.h>
#include <nn/am.h>
#include <nn/ndm.h>
#include <nn/cfg.h>
#include <nn/ptm_Private.h>

#include <nn/cup.h>

#include "demo.h"
#include "scrollBuffer.h"
#include "VersionDetect.h"
#include "HeapManager.h"

namespace
{
const s32 s_GxHeapSize = 0x800000;
uptr s_GxHeap;

demo::RenderSystemDrawing s_RenderSystem;
ScrollBuffer s_scrollBufferInstance;
ScrollBuffer *s_scrollBuffer;

char s_updaterBuffer[1 << 20] NN_ATTRIBUTE_ALIGN(4096);

// デモの初期化
void Initialize()
{
    // NuiShellの初期化 (CUPに必須)
    NN_UTIL_PANIC_IF_FAILED(nn::ns::CTR::InitializeForShell());

    // ndmの初期化
    nn::ndm::Initialize();

    // 全デーモンの自律動作をacの自動接続も含めて止める
    nn::ndm::SuspendScheduler();

    // amの初期化
    nn::am::InitializeForSystemMenu();

    // fsの初期化 (カード確認用)
    nn::fs::Initialize();

    // appletの初期化
    //nn::applet::InitializeForSystem( nn::applet::PHOME_MENU_APPLET_ID, nn::applet::TYPE_SYS );
    //nn::applet::Initialize( nn::applet::TEST2_APPLET_ID);
    //nn::applet::SetAppletMode();
    nn::applet::Enable();

    nn::cfg::Initialize();

    // デバイスメモリの設定
    const s32 DEVICE_MEMORY_SIZE = 32 * 1024 * 1024;
    NN_UTIL_PANIC_IF_FAILED(nn::os::SetDeviceMemorySize(DEVICE_MEMORY_SIZE));

    // ヒープの初期化
    InitializeHeap();

    // 描画インスタンスの初期化
    s_GxHeap = reinterpret_cast<uptr>(ForceAllocate(s_GxHeapSize));
    s_RenderSystem.Initialize(s_GxHeap, s_GxHeapSize);

    // 描画インスタンスの初期化
    s_scrollBufferInstance.Initialize(&s_RenderSystem);
    s_scrollBuffer = &s_scrollBufferInstance;

    // GPU利用宣言
    nn::applet::AssignGpuRight();
}

// 消費時間取得用関数群
s64 s_StartTick;
void SetTick()
{
    s_StartTick = nn::os::Tick::GetSystemCurrent();
}
s64 GetConsumedMillisec()
{
    s64 endTick = nn::os::Tick::GetSystemCurrent();
    nn::os::Tick consumed(endTick - s_StartTick);
    return ((nn::fnd::TimeSpan) consumed).GetMilliSeconds();
}

// 動いていることを知らせるための、くるくる画面表示取得用メソッド
const char s_progress[] = "-\\|/";
s32 s_progressIndex = 0;
char GetProgressChar()
{
    s_progressIndex = (s_progressIndex + 1) % (sizeof(s_progress) - 1);
    return s_progress[s_progressIndex];
}

nn::Result UpdateSequence(bool *isHandledError, bool* needUpdate)
{
    nn::Result result;
    nn::Result lastResult = nn::ResultSuccess();

    /********************* CUPの初期化 *******************/
    s_scrollBuffer->AppendText("Initializing Cup Library")->Render();
    SetTick(); // 初期化開始前の時間をセット
    result = nn::cup::CTR::Initialize(s_updaterBuffer, sizeof(s_updaterBuffer));
    if (result == nn::cup::CTR::ResultUpdatePartitionNotFound())
    {
        s_scrollBuffer->AppendText(" - Update Partition Not Found (%lldmsec)", GetConsumedMillisec())->Render();
        s_scrollBuffer->AppendText("")->Render();
        *isHandledError = true;
        return result;
    }
    if (result == nn::cup::CTR::ResultUpdateNotRequired())
    {
        s_scrollBuffer->AppendText(" - Already Updated (%lldmsec)", GetConsumedMillisec())->Render();
        s_scrollBuffer->AppendText("")->Render();
        *isHandledError = true;
        return result;
    }
    if (result == nn::cup::CTR::ResultInvalidUpdatePartitionFormat())
    {
        s_scrollBuffer->AppendText(" - Invalid Update Partition (%lldmsec)", GetConsumedMillisec())->Render();
        s_scrollBuffer->AppendText("")->Render();
        *isHandledError = true;
        return result;
    }
    NN_UTIL_RETURN_IF_FAILED(result);

    s_scrollBuffer->AppendText(" - Need Update (%lldmsec)", GetConsumedMillisec())->Render();
    *needUpdate = true;
    s_scrollBuffer->AppendText("")->Render();

    // Initializeに成功した場合のみ、再びInitializeするためにFinalizeが必要
    SetTick();
    s_scrollBuffer->AppendText("Finalizing Cup Library")->Render();
    NN_UTIL_RETURN_IF_FAILED(nn::cup::CTR::Finalize());

    return lastResult;
}
}

nn::Result ExecuteCup(ScrollBuffer* scrollBuf, bool* needUpdte)
{
    nn::Result result;
    bool isHandledError = false;
    result = UpdateSequence(&isHandledError, needUpdte);
    if (isHandledError == false && result.IsFailure())
    {
        {
            // それ以外の場合は、Resultを表示
            scrollBuf->AppendText(" - Unhandled Error: 0x%08x", result.GetPrintableBits());
            scrollBuf->AppendText("")->Render();
        }
    }

    return result;
}

extern "C" void nnMain()
{
    NN_LOG("Start Self Cup\n");
    nn::Result result;
    Initialize();

    nn::ProgramId MMEN_PROGRAM_ID = 0x0004003000008202;

    nn::cfg::CfgRegionCode region = nn::cfg::GetRegion();
    switch(region)
    {
        case nn::cfg::CFG_REGION_AMERICA:
        {
            MMEN_PROGRAM_ID = 0x0004003000008f02;
        }
        break;

        case nn::cfg::CFG_REGION_EUROPE:
        case nn::cfg::CFG_REGION_AUSTRALIA:
        {
            MMEN_PROGRAM_ID = 0x0004003000009802;
        }
        break;

        case nn::cfg::CFG_REGION_JAPAN:
        {
            MMEN_PROGRAM_ID = 0x0004003000008202;
        }
        break;
    }

    nn::am::ProgramInfo outInfos;
    result = nn::am::GetProgramInfos(&outInfos, nn::fs::MEDIA_TYPE_NAND, &MMEN_PROGRAM_ID, 1);
    bool needUpdate = false;
    if (result.IsSuccess())
    {
        result = ExecuteCup(s_scrollBuffer, &needUpdate);
    }
    else if(result == nn::am::ResultNotFound())
    {
        s_scrollBuffer->AppendText("Cannot find Home Menu");
    }

    if(needUpdate)
    {
        s_scrollBuffer->AppendText("Need to execute Self Cup");
    }

    s_scrollBuffer->AppendText("")->Render();
    VerDef versionData;
    GetSystemVersion(&versionData, region);

    s_scrollBuffer->AppendText("Version: %d.%d.%d-%d%c", versionData.cup.majorVersion, versionData.cup.minorVersion,
            versionData.cup.microVersion, versionData.nup.majorVersion, nn::cfg::GetRegionCodeA3(region)[0]);

    s_scrollBuffer->AppendText("")->Render();

    for(;;)
    {
        s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY0);
        if(needUpdate)
        {
            s_RenderSystem.SetClearColor(NN_GX_DISPLAY0, 1, 0, 0, 1);
        }
        else if(result.IsSuccess() || result == nn::cup::CTR::ResultUpdateNotRequired())
        {
            s_RenderSystem.SetClearColor(NN_GX_DISPLAY0, 0, 1, 0, 1);
        }
        else
        {
            s_RenderSystem.SetClearColor(NN_GX_DISPLAY0, 1, 0, 0, 1);
        }
        s_RenderSystem.Clear();
        s_RenderSystem.SwapBuffers();
        s_RenderSystem.SetRenderTarget(NN_GX_DISPLAY1);
        if(needUpdate)
        {
            s_RenderSystem.SetClearColor(NN_GX_DISPLAY1, 1, 0, 0, 1);
        }
        else if(result.IsSuccess() || result == nn::cup::CTR::ResultUpdateNotRequired())
        {
            s_RenderSystem.SetClearColor(NN_GX_DISPLAY1, 0, 1, 0, 1);
        }
        else
        {
            s_RenderSystem.SetClearColor(NN_GX_DISPLAY1, 1, 0, 0, 1);
        }
        s_scrollBuffer->ReplaceText("%c Finished", GetProgressChar())->Render();

        if ( nn::applet::IsExpectedToCloseApplication() )
        {
            nn::applet::PrepareToCloseApplication();
            nn::applet::CloseApplication();
        }

    }
}