示例#1
0
bool OpenConnection(cec_device_type type = CEC_DEVICE_TYPE_RECORDING_DEVICE)
{
  g_config.Clear();
  snprintf(g_config.strDeviceName, 13, "CEC-config");
  g_config.callbackParam      = NULL;
  g_config.clientVersion      = (uint32_t)CEC_CLIENT_VERSION_1_8_1;
  g_callbacks.CBCecLogMessage = &CecLogMessage;
  g_callbacks.CBCecKeyPress   = &CecKeyPress;
  g_callbacks.CBCecCommand    = &CecCommand;
  g_config.callbacks          = &g_callbacks;

  g_config.deviceTypes.add(type);

  g_parser = LibCecInitialise(&g_config);
  if (!g_parser)
    return false;

  // init video on targets that need this
  g_parser->InitVideoStandalone();

  CStdString strPort;
  cec_adapter devices[10];
  uint8_t iDevicesFound = g_parser->FindAdapters(devices, 10, NULL);
  if (iDevicesFound <= 0)
  {
    PrintToStdOut("autodetect FAILED");
    UnloadLibCec(g_parser);
    return false;
  }
  else
  {
    strPort = devices[0].comm;
  }

  PrintToStdOut("opening a connection to the CEC adapter...");
  if (!g_parser->Open(strPort.c_str()))
  {
    PrintToStdOut("unable to open the device on port %s", strPort.c_str());
    UnloadLibCec(g_parser);
    return false;
  }

  g_parser->GetCurrentConfiguration(&g_config);
  PrintToStdOut("CEC Parser created - libCEC version %s", g_parser->ToString((cec_server_version)g_config.serverVersion));

  return true;
}
示例#2
0
int main (int UNUSED(argc), char *UNUSED(argv[]))
{
  g_callbacks.Clear();
  g_config.Clear();
  PrintToStdOut("=== USB-CEC Adapter Configuration ===\n");
  if (!OpenConnection())
    return 1;

  if (!PowerOnTV())
    return 1;

  bool bAddressOk(false);
  while (!bAddressOk)
  {
    uint16_t iAddress = FindPhysicalAddress();

    PrintToStdOut("Physical address: %4X", iAddress);
    PrintToStdOut("Is this correct (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    bAddressOk = (input == "y" || input == "Y");
  }

  g_parser->GetCurrentConfiguration(&g_config);

  {
    cec_menu_language lang;
    if (g_parser->GetDeviceMenuLanguage(CECDEVICE_TV, &lang))
    {
      PrintToStdOut("TV menu language: %s", lang.language);
      PrintToStdOut("Do you want the application to use the menu language of the TV (y/n)?");
      string input;
      getline(cin, input);
      cin.clear();
      g_config.bUseTVMenuLanguage = (input == "y" || input == "Y") ? 1 : 0;
    }
    else
    {
      PrintToStdOut("The TV did not respond properly to the menu language request.");
    }
  }

  {
    PrintToStdOut("Do you want to make the CEC adapter the active source when starting the application (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    g_config.bActivateSource = (input == "y" || input == "Y") ? 1 : 0;
  }

  {
    PrintToStdOut("Do you want to power on the TV when starting the application (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    if (input == "y" || input == "Y")
      g_config.wakeDevices.Set(CECDEVICE_TV);
  }

  {
    PrintToStdOut("Do you want to power off CEC devices when closing the application (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    if (input == "y" || input == "Y")
      g_config.powerOffDevices.Set(CECDEVICE_TV);
  }

  {
    PrintToStdOut("Do you want to power off CEC devices when the screensaver is activated (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    g_config.bPowerOffScreensaver = (input == "y" || input == "Y") ? 1 : 0;
  }

  {
    PrintToStdOut("Do you want to put the PC in standby when the TV is put in standby mode (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    g_config.bPowerOffOnStandby = (input == "y" || input == "Y") ? 1 : 0;
  }

  {
    PrintToStdOut("Do you want to send an inactive source message when stopping the application (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    g_config.bSendInactiveSource = (input == "y" || input == "Y") ? 1 : 0;
  }

  PrintToStdOut("\n\n=== USB-CEC Adapter Configuration Summary ===");
  PrintToStdOut("HDMI port number:                                        %d", g_config.iHDMIPort);
  PrintToStdOut("Connected to HDMI device:                                %X", (uint8_t)g_config.baseDevice);
  PrintToStdOut("Physical address:                                        %4X", g_config.iPhysicalAddress);
  PrintToStdOut("Use the TV's language setting:                           %s", g_config.bUseTVMenuLanguage ? "yes" : "no");
  PrintToStdOut("Make the adapter the active source when starting XBMC:   %s", g_config.bActivateSource ? "yes" : "no");
  PrintToStdOut("Power on the TV when starting XBMC:                      %s", g_config.wakeDevices.IsSet(CECDEVICE_BROADCAST) ? "yes" : "no");
  PrintToStdOut("Power off devices when stopping XBMC:                    %s", g_config.powerOffDevices.IsSet(CECDEVICE_BROADCAST) ? "yes" : "no");
  PrintToStdOut("Put devices in standby mode when activating screensaver: %s", g_config.bPowerOffScreensaver ? "yes" : "no");
  PrintToStdOut("Put this PC in standby mode when the TV is switched off: %s", g_config.bPowerOffOnStandby ? "yes" : "no");
  PrintToStdOut("Send an inactive source message when stopping XBMC:      %s\n\n", g_config.bSendInactiveSource ? "yes" : "no");

  PrintToStdOut("Storing settings ...");
  if (g_parser->PersistConfiguration(&g_config))
    PrintToStdOut("Settings stored.");
  else
    PrintToStdOut("The settings could not be stored");

  ofstream configOutput;
  configOutput.open("usb_2548_1001.xml");
  if (configOutput.is_open())
  {
    CStdString strWakeDevices;
    for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
      if (g_config.wakeDevices[iPtr])
        strWakeDevices.AppendFormat(" %d", iPtr);
    CStdString strStandbyDevices;
    for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
      if (g_config.powerOffDevices[iPtr])
        strStandbyDevices.AppendFormat(" %d", iPtr);

    configOutput <<
        "<settings>\n" <<
          "\t<setting id=\"enabled\" value=\"1\" />\n" <<
          "\t<setting id=\"activate_source\" value=\"" << (int)g_config.bActivateSource << "\" />\n" <<
          "\t<setting id=\"wake_devices\" value=\"" << strWakeDevices.c_str() << "\" />\n" <<
          "\t<setting id=\"standby_devices\" value=\"" << strStandbyDevices.c_str() << "\" />\n" <<
          "\t<setting id=\"cec_standby_screensaver\" value=\"" << (int)g_config.bPowerOffScreensaver << "\" />\n" <<
          "\t<setting id=\"standby_pc_on_tv_standby\" value=\"" << (int)g_config.bPowerOffOnStandby << "\" />\n" <<
          "\t<setting id=\"use_tv_menu_language\" value=\"" << (int)g_config.bUseTVMenuLanguage << "\" />\n" <<
          "\t<setting id=\"physical_address\" value=\"" << hex << g_config.iPhysicalAddress << "\" />\n" <<
          "\t<setting id=\"cec_hdmi_port\" value=\"" << g_config.iHDMIPort << "\" />\n" <<
          "\t<setting id=\"connected_device\" value=\"" << (int)g_config.baseDevice << "\" />\n" <<
          "\t<setting id=\"port\" value=\"\" />\n" <<
          "\t<setting id=\"send_inactive_source\" value=\"" << (int)g_config.bSendInactiveSource << "\" />\n" <<
        "</settings>";
    configOutput.close();

    PrintToStdOut("The configuration has been stored in 'usb_2548_1001.xml'. Copy this file to ~/.userdata/peripheral_data to use it in XBMC");
  }

  g_parser->StandbyDevices();
  g_parser->Close();
  UnloadLibCec(g_parser);

  PrintToStdOut("Press enter to close this wizard.");
  string input;
  getline(cin, input);
  return 0;
}
示例#3
0
文件: main.cpp 项目: aep/cecd
int main (int argc, char *argv[])
{
    if(argc<2){
        fprintf(stderr,"usage: echo /path/to/echo.method\n");
        exit(1);
    }
    ubus_t * service=ubus_create(argv[1]);
    if(service==0){
        perror("ubus_create");
        exit(0);
    }



    g_config.Clear();
    g_callbacks.Clear();
    snprintf(g_config.strDeviceName, 13, "XBMC");
    g_config.clientVersion       = CEC_CONFIG_VERSION;
    g_config.bActivateSource     = 0;
    //    g_callbacks.CBCecLogMessage  = &CecLogMessage;
    //    g_callbacks.CBCecKeyPress    = &CecKeyPress;
    //    g_callbacks.CBCecCommand     = &CecCommand;
    //    g_callbacks.CBCecAlert       = &CecAlert;
    //    g_config.callbacks           = &g_callbacks;


    g_config.deviceTypes.Add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
    ICECAdapter *parser = LibCecInitialise(&g_config);
    if (!parser)
    {
#ifdef __WINDOWS__
        cout << "Cannot load libcec.dll" << endl;
#else
        cout << "Cannot load libcec.so" << endl;
#endif
        if (parser)
            UnloadLibCec(parser);
        return 1;
    }

    // init video on targets that need this
    parser->InitVideoStandalone();


    if (g_strPort.empty())
    {
        if (!g_bSingleCommand)
            cout << "no serial port given. trying autodetect: ";
        cec_adapter devices[10];
        uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
        if (iDevicesFound <= 0)
        {
            if (g_bSingleCommand)
                cout << "autodetect ";
            cout << "FAILED" << endl;
            UnloadLibCec(parser);
            return 1;
        }
        else
        {
            if (!g_bSingleCommand)
            {
                cout << endl << " path:     " << devices[0].path << endl <<
                    " com port: " << devices[0].comm << endl << endl;
            }
            g_strPort = devices[0].comm;
        }
    }

    fprintf(stderr,"opening a connection to the CEC adapter...");

    if (!parser->Open(g_strPort.c_str()))
    {
        fprintf(stderr,"unable to open the device on port %s", g_strPort.c_str());
        UnloadLibCec(parser);
        return 1;
    }

    if (!g_bSingleCommand)
        fprintf(stderr,"waiting for input\n");




    signal(SIGPIPE, SIG_IGN);


    fd_set rfds;
    char buff [2000];
    for(;;) {
        FD_ZERO (&rfds);
        int maxfd=ubus_select_all(service,&rfds);
        if (select(maxfd+2, &rfds, NULL, NULL, NULL) < 0){
            perror("select");
            exit(1);
        }
        ubus_activate_all(service,&rfds,0);
        ubus_chan_t * chan=0;
        while((chan=ubus_ready_chan(service))){
            int len = ubus_read(chan,&buff,2000);
            if (len < 1) {
                ubus_disconnect(chan);
            }else {
                if (strncmp(buff, "volup", 5) == 0) {
                    parser->VolumeUp();
                    ubus_write(chan,&buff,len);
                } else if (strncmp(buff, "voldown", 7) == 0) {
                    parser->VolumeDown();
                    ubus_write(chan,&buff,len);
                } else if (strncmp(buff, "mute", 4) == 0) {
                    parser->AudioToggleMute();
                    ubus_write(chan,&buff,len);
                }
            }
        }
    }
    fprintf(stderr,"bye\n");
    ubus_destroy(service);


    parser->Close();
    UnloadLibCec(parser);

    if (g_logOutput.is_open())
        g_logOutput.close();

    return 0;
}